/**
 * 泛型函数（难点）
 * 语法结构：
 * let 函数名 = <T>(x:T):T=>{
 * 
 * }
 * 
 * let 函数名 = <类型参数>(x:类型参数):类型参数 => {
 * 
 * }
 */

// 定义泛型函数
// const fn = <T, P>(x: T, y: P): T | P => {
//     return x
// }

// // 调用泛型函数
// fn<number, string>(101, 'hello')

// fn<boolean, number>(true, 100)

// const fn = <T>(x: T, y: T): T => {
//     return x
// }

// fn<number>(10, 20)
// fn(10, 20)

// 泛型约束
interface A {
    length: number
}

// T 继承了 A，A 中有 length 属性，所有 T 中也肯定有 length 属性
let fn = <T extends A>(x: T): number => {
    return x.length
}

/**
 * let 函数名 = <T>(x: T): T => { }
    * T 是类型参数
 * T 是什么时候确定的？
    * 调用函数的时候，传入具体类型，T 捕获到这个类型，函数任何位置都可以使用
 * 泛型函数的好处？
    * 让函数可以支持不同的类型（复用）且保证类型是安全的
 * 调用函数，什么时候可以省略参数？
    * 传入的数据可以推断出类型，就可以省略
 */

export default {}
